/*
 * @Author: 九阳
 * @Date: 2021-11-26 14:53:38
 * @LastEditors: 九阳
 * @LastEditTime: 2023-03-14 09:13:39
 */
/**
 * 图片格式转换
 * @param file
 */
export function getBase64(file: File) {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.readAsDataURL(file);
    reader.onload = () => resolve(reader.result);
    reader.onerror = (error) => reject(error);
  });
}
/**
 * 生成id
 */
export function getUUID(): string {
  let d = new Date().getTime();
  if (window.performance && typeof window.performance.now === "function") {
    d += performance.now();
  }
  const uuid = "xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx".replace(
    /[xy]/g,
    function (c) {
      const r = (d + Math.random() * 16) % 16 | 0;
      d = Math.floor(d / 16);
      return (c === "x" ? r : (r & 0x3) | 0x8).toString(16);
    }
  );
  return uuid;
}
export function checkBoolean(value: any): boolean {
  if (value !== null && value !== undefined && value !== "") {
    return true;
  }
  return false;
}

//一个值在 该数组值某字段这都相同 返回 true
/**
 *
 * @param value 值
 * @param lists 数组
 * @param listKey 字段编码
 */
export const ArrayEvery = (
  value: string,
  lists: any,
  listKey: string
): boolean => {
  return lists.every((list: any) => list[listKey] === value);
};
//一个值在 该数组值某字段存在 true,
/**
 *
 * @param value 值
 * @param lists 数组
 * @param listKey 字段编码
 */
export const ArraySome = (
  value: string,
  lists: any,
  listKey: string
): boolean => {
  return lists.some((list: any) => list[listKey] === value);
};

// 字符串方法

/**
 *
 * @param content 字符串内容
 * @param value  查询的字符
 * @param index  开始位置 不传默认 0
 *  查询的字符在改字符内容存在 返回true
 */

export const includesString = (
  content: string,
  value: string,
  index?: number | 0
): boolean => {
  return content.includes(value, index);
};
/**
 *
 * @param content 字符串内容
 * @param value  查询的字符
 * @param index  开始位置 不传默认 0
 *  查询字符内容已字符（value）开始  返回true
 */
export const startsWithString = (
  content: string,
  value: string,
  index?: number | 0
): boolean => {
  return content.startsWith(value, index);
};

/**
 *
 * @param content 字符串内容
 * @param value  查询的字符
 * @param index  开始位置 不传默认 0
 *  查询字符内容已字符（value）结尾 返回true
 */
export const endWithString = (
  content: string,
  value: string,
  index?: number | 0
): boolean => {
  return content.endsWith(value, index);
};

/**
 *
 * @param value 字符串
 * @param index 次数
 * 返回将原来字符串重复几次
 */
export const repeatString = (value: string, index: number | 0): string => {
  return value.repeat(index);
};

/**
 *
 * @param content 原来字符
 * @param value  补充字符
 * 在原来字符头部位置补充字符串
 */
export const padStartString = (content: string, value: string): string => {
  const index = content.length + value.length;
  return content.padStart(index, value);
};

/**
 *
 * @param content 原来字符
 * @param value  补充字符
 * 在原来字符结尾位置补充字符串
 */
export const padEndString = (content: string, value: string): string => {
  const index = content.length + value.length;
  return content.padEnd(index, value);
};

//  map 值可以是 undefined, function  JSON 值不可以是 function
export const mapToJson = (map: any): any => {
  return JSON.stringify([...map]);
};

export const jsonToMap = (json: any): any => {
  return new Map(JSON.parse(json));
};

/**
 * 判断一个日期是否是工作日
 * @param data 日期
 */
export const isWeekly = (data: any): boolean => {
  const day = data.getDay() % 6;
  if (day !== 0) {
    return true;
  }
  return false;
};

/**
 * 判断奇数偶数
 * @param num 数字
 */
export const isEve = (num: any): boolean => {
  const day = Number(num) % 2;
  if (day !== 0) {
    return true;
  }
  return false;
};

/**
 * 从Date对象中获取时间
 * @param date 日期
 * @param start 默认0
 * @param end 默认 8
 */
export const timeFromDate = (
  date: any,
  start: any = 0,
  end: any = 8
): string => {
  return date.toTimeString().slice(start, end);
};

/**
 * 保留指定小数位
 * @param data   数据
 * @param fixed  几位小数
 */
export const toFixed = (data: any, fixed: any): any => {
  return ~~(Math.pow(10, fixed) * data) / Math.pow(10, fixed);
};

/**
 * 滚动至页面顶部
 */
export const goToTop = () => {
  window.scrollTo(0, 0);
};
/**
 * 获取所有参数的平均值
 * @param args 数据
 */
export const average = (...args: any[]) => {
  return args.reduce((a, b) => a + b) / args.length;
};
/**
 * 摄氏度转华氏度
 * @param celsius 摄氏度
 */
export const celsiusToFahrenheit = (celsius: any) => {
  return (celsius * 9) / 5 + 32;
};
/**
 * 华氏度转摄氏度
 * @param fahrenheit 华氏度
 */
export const fahrenheitToCelsius = (fahrenheit: any) => {
  return ((fahrenheit - 32) * 5) / 9;
};
/**
 * 时间格式化
 * @param dateTime 时间
 * @param fmt 格式
 */
export const timeFormat = (dateTime: any, fmt: any = "yyyy-mm-dd") => {
  // 如果为null,则格式化当前时间
  if (!dateTime) dateTime = Number(new Date());
  // 如果dateTime长度为10或者13，则为秒和毫秒的时间戳，如果超过13位，则为其他的时间格式
  if (dateTime.toString().length == 10) dateTime *= 1000;
  const date = new Date(dateTime);
  let ret;
  const opt: any = {
    "y+": date.getFullYear().toString(), // 年
    "m+": (date.getMonth() + 1).toString(), // 月
    "d+": date.getDate().toString(), // 日
    "h+": date.getHours().toString(), // 时
    "M+": date.getMinutes().toString(), // 分
    "s+": date.getSeconds().toString(), // 秒
    // 有其他格式化字符需求可以继续添加，必须转化成字符串
  };
  for (const k in opt) {
    ret = new RegExp("(" + k + ")").exec(fmt);
    if (ret) {
      fmt = fmt.replace(
        ret[1],
        ret[1].length == 1 ? opt[k] : opt[k].padStart(ret[1].length, "0")
      );
    }
  }
  return fmt;
};
/**
 * 时间格式化
 * @param dateTime 时间
 * @param fmt 格式
 */
export const timeFormat2 = (dateTime: any, format: any = "yyyy-mm-dd") => {
  // 如果为null,则格式化当前时间
  if (!dateTime) dateTime = Number(new Date());
  // 如果dateTime长度为10或者13，则为秒和毫秒的时间戳，如果超过13位，则为其他的时间格式
  if (dateTime.toString().length == 10) dateTime *= 1000;
  const timestamp = +new Date(Number(dateTime));

  const timer = (Number(new Date()) - timestamp) / 1000;
  // 如果小于5分钟,则返回"刚刚",其他以此类推
  let tips = "";
  switch (true) {
    case timer < 300:
      tips = "刚刚";
      break;
    case timer >= 300 && timer < 3600:
      const t: any = timer / 60;
      tips = parseInt(t) + "分钟前";
      break;
    case timer >= 3600 && timer < 86400:
      const t1: any = timer / 3600;
      tips = parseInt(t1) + "小时前";
      break;
    case timer >= 86400 && timer < 2592000:
      const t2: any = timer / 86400;
      tips = parseInt(t2) + "天前";
      break;
    default:
      // 如果format为false，则无论什么时间戳，都显示xx之前
      if (!format) {
        if (timer >= 2592000 && timer < 365 * 86400) {
          const t: any = timer / (86400 * 30);
          tips = parseInt(t) + "个月前";
        } else {
          const t: any = timer / (86400 * 365);
          tips = parseInt(t) + "年前";
        }
      } else {
        tips = timeFormat(timestamp, format);
      }
  }
  return tips;
};
/**
 * 手机号中间4位加密
 * @param phone 手机号
 */
export const phoneFormat = (phone: any = 0) => {
  return String(phone).replace(/^(\d{3})\d{4}(\d+)$/, "$1****$2");
};
/**
 * 格式化显示手机号
 * @param val 手机号
 */
export const formatPhone = (val: string) => {
  if (val) {
    const matches = /^(\d{3})(\d{4})(\d{4})$/.exec(val);
    if (matches) {
      return matches[1] + " " + matches[2] + " " + matches[3];
    }
  }
  return val;
};
/**
 * 格式化显示银行卡号
 * @param value 卡号
 */
export const trimCardNumber = (value: string) => {
  value = String(value || "")
    .replace(/\s/g, "")
    .replace(/(.{4})/g, "$1 ");
  return value;
};
/**
 * 验证手机号
 * @param value 手机号
 */
export const isPhone = (value: string): boolean => {
  return (
    typeof value === "string" &&
    /^(0|86|17951)?(13[0-9]|15[012356789]|166|17[3678]|18[0-9]|14[57])[0-9]{8}$/.test(
      value
    )
  );
};

/**
 * 验证身份证号
 * @param value 身份证号
 */
export const isIDCard = (value: string): boolean => {
  return (
    typeof value === "string" &&
    /^(^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$)|(^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])((\d{4})|\d{3}[Xx])$)$/.test(
      value
    )
  );
};
/**
 * 验证车牌号
 * @param value 车牌号
 */
export const isVehicleId = (value: string): boolean => {
  return (
    typeof value === "string" &&
    /^(([京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领][A-Z](([0-9]{5}[DF])|([DF]([A-HJ-NP-Z0-9])[0-9]{4})))|([京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领][A-Z][A-HJ-NP-Z0-9]{4}[A-HJ-NP-Z0-9挂学警港澳使领]))$/.test(
      value
    )
  );
};
/**
 * 验证邮箱号
 * @param value 邮箱号
 */
export const isEmail = (value: string): boolean => {
  // return (
  //   typeof value === "string" &&
  //   /^\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$/.test(
  //     value
  //   )
  // );
  return /^([A-Za-z0-9_\-\.])+\@(163.com|qq.com|42du.cn)$/.test(value);
};

/**
 * 验证url
 * @param value url
 */
export const isUrl = (value: string): boolean => {
  return /^(?:http(s)?:\/\/)?[\w.-]+(?:\.[\w\.-]+)+[\w\-\._~:/?#[\]@!\$&'\*\+,;=.]+$/.test(
    value
  );
  // return /http(s)?:\/\/([\w-]+\.)+[\w-]+(\/[\w-.\/?%&=]*)?/.test(value);
};

/**
 * 验证日期格式
 * @param value 时间
 */
export const isDate = (value: any): boolean => {
  return !/Invalid|NaN/.test(new Date(value).toString());
};

/**
 * 验证ISO类型的日期格式
 * @param value
 */
// export const dateISO = (value: any): boolean => {
//   return /^\d{4}[\/\-](0?[1-9]|1[012])[\/\-](0?[1-9]|[12][0-9]|3[01])$/.test(
//     value
//   );
// };

export const carNo = (value: string): boolean => {
  // 新能源车牌
  const xreg =
    /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}(([0-9]{5}[DF]$)|([DF][A-HJ-NP-Z0-9][0-9]{4}$))/;
  // 旧车牌
  const creg =
    /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}[A-HJ-NP-Z0-9]{4}[A-HJ-NP-Z0-9挂学警港澳]{1}$/;
  if (value.length === 7) {
    return creg.test(value);
  } else if (value.length === 8) {
    return xreg.test(value);
  } else {
    return false;
  }
};

/**
 * 验证十进制数字
 * @param value 数字
 */
export const isNumber = (value: any): boolean => {
  return /^(?:-?\d+|-?\d{1,3}(?:,\d{3})+)?(?:\.\d+)?$/.test(value);
};
/**
 * 验证整数
 * @param value 数字
 */
export const isDigits = (value: any): boolean => {
  return /^\d+$/.test(value);
};
/**
 * 金额，只允许保留两位小数
 * @param value 金额
 */
export const amount = (value: any): boolean => {
  //金额，只允许保留两位小数
  return /^[1-9]\d*(,\d{3})*(\.\d{1,2})?$|^0\.\d{1,2}$/.test(value);
};
/**
 * 只能输入字母
 * @param value
 */
export const letter = (value: any): boolean => {
  return /^[a-zA-Z]*$/.test(value);
};
/**
 * 只能输入字母或者数字
 * @param value
 */
export const enOrNum = (value: any): boolean => {
  //英文或者数字
  const reg = /^[0-9a-zA-Z]*$/g;
  return reg.test(value);
};
/**
 * 是否固定电话
 * @param value
 */
export const landline = (value: any): boolean => {
  const reg = /^\d{3,4}-\d{7,8}(-\d{3,4})?$/;
  return reg.test(value);
};
/**
 * 判断是否为空
 * @param value
 */
export const empty = (value: any): boolean => {
  switch (typeof value) {
    case "undefined":
      return true;
    case "string":
      if (value.replace(/(^[ \t\n\r]*)|([ \t\n\r]*$)/g, "").length == 0)
        return true;
      break;
    case "boolean":
      if (!value) return true;
      break;
    case "number":
      if (0 === value || isNaN(value)) return true;
      break;
    case "object":
      if (null === value || value.length === 0) return true;
      for (const i in value) {
        return false;
      }
      return true;
  }
  return false;
};
/**
 * 密码强度的校验  
   说明：密码中必须包含字母、数字、特称字符，至少8个字符，最多30个字符
 * @param value 
 */
export const password = (value: any): boolean => {
  const passwordReg = /(?=.*[0-9])(?=.*[a-zA-Z])(?=.*[^a-zA-Z0-9]).{8,30}/;
  return passwordReg.test(value);
};
/**
 * 是否json字符串
 * @param value
 */
export const jsonString = (value: any): boolean => {
  if (typeof value === "string") {
    try {
      const obj = JSON.parse(value);
      if (typeof obj === "object" && obj) {
        return true;
      } else {
        return false;
      }
    } catch (e) {
      return false;
    }
  }
  return false;
};

/**
 * 全局唯一标识符
 * @param len
 * @param firstU
 * @param radix
 */
export function guid(
  len: any = 32,
  firstU: any = true,
  radix: any = null
): string {
  const chars =
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".split("");
  const uuid = [];
  radix = radix || chars.length;

  if (len) {
    // 如果指定uuid长度,只是取随机的字符,0|x为位运算,能去掉x的小数位,返回整数位
    for (let i = 0; i < len; i++) uuid[i] = chars[0 | (Math.random() * radix)];
  } else {
    let r;
    // rfc4122标准要求返回的uuid中,某些位为固定的字符
    uuid[8] = uuid[13] = uuid[18] = uuid[23] = "-";
    uuid[14] = "4";

    for (let i = 0; i < 36; i++) {
      if (!uuid[i]) {
        r = 0 | (Math.random() * 16);
        uuid[i] = chars[i == 19 ? (r & 0x3) | 0x8 : r];
      }
    }
  }
  // 移除第一个字符,并用u替代,因为第一个字符为数值时,该guuid不能用作id或者class
  if (firstU) {
    uuid.shift();
    return "u" + uuid.join("");
  } else {
    return uuid.join("");
  }
}

/**
 * 对象转URL参数
 * queryParams(data, isPrefix = true, arrayFormat = 'brackets')
 * 对象转url参数
 * @param {*} data,对象
 * @param {*} isPrefix,是否自动加上"?"
 */
export function queryParams(
  data: any = {},
  isPrefix = true,
  arrayFormat: any = "brackets"
) {
  const prefix = isPrefix ? "?" : "";
  const _result = [];
  if (["indices", "brackets", "repeat", "comma"].indexOf(arrayFormat) == -1)
    arrayFormat = "brackets";
  for (const key in data) {
    const value = data[key];
    // 去掉为空的参数
    if (["", undefined, null].indexOf(value) >= 0) {
      continue;
    }
    // 如果值为数组，另行处理
    if (value.constructor === Array) {
      // e.g. {ids: [1, 2, 3]}
      switch (arrayFormat) {
        case "indices":
          // 结果: ids[0]=1&ids[1]=2&ids[2]=3
          for (let i = 0; i < value.length; i++) {
            _result.push(key + "[" + i + "]=" + value[i]);
          }
          break;
        case "brackets":
          // 结果: ids[]=1&ids[]=2&ids[]=3
          value.forEach((_value) => {
            _result.push(key + "[]=" + _value);
          });
          break;
        case "repeat":
          // 结果: ids=1&ids=2&ids=3
          value.forEach((_value) => {
            _result.push(key + "=" + _value);
          });
          break;
        case "comma":
          // 结果: ids=1,2,3
          let commaStr = "";
          value.forEach((_value) => {
            commaStr += (commaStr ? "," : "") + _value;
          });
          _result.push(key + "=" + commaStr);
          break;
        default:
          value.forEach((_value) => {
            _result.push(key + "[]=" + _value);
          });
      }
    } else {
      _result.push(key + "=" + value);
    }
  }
  return _result.length ? prefix + _result.join("&") : "";
}
/**
 * console.log(queryParams({name:'li',age:20}))
// 结果：?name=li&age=20

const data = {name: '冷月夜',fruits: ['apple', 'banana', 'orange']}
queryParams(this.data, true, 'indices');
// 结果为：?name=冷月夜&fruits[0]=apple&fruits[1]=banana&fruits[2]=orange

queryParams(this.data, true, 'brackets');
// 结果为：?name=冷月夜&fruits[]=apple&fruits[]=banana&fruits[]=orange

queryParams(this.data, true, 'repeat');
// 结果为：?name=冷月夜&fruits=apple&fruits=banana&fruits=orange

queryParams(this.data, true, 'comma');
// 结果为：?name=冷月夜&fruits=apple,banana,orange
 */

/**
 * 去除空格
str 字符串
pos 去除那些位置的空格，可选为：both-默认值，去除两端空格，left-去除左边空格，right-去除右边空格，all-去除包括中间和两端的所有空格
 * @param str 
 * @param pos 
 */
export function trim(str: any, pos = "both") {
  if (pos === "both") {
    return str.replace(/^\s+|\s+$/g, "");
  } else if (pos === "left") {
    return str.replace(/^\s*/, "");
  } else if (pos === "right") {
    return str.replace(/(\s*$)/g, "");
  } else if (pos === "all") {
    return str.replace(/\s+/g, "");
  } else {
    return str;
  }
}

/**
 * 冒泡排序
 * @param arr 数组
 */
export function bubbleSort(arr: any) {
  const len = arr.length;
  for (let i = 0; i < len - 1; i++) {
    // 从第一个元素开始，比较相邻的两个元素，前者大就交换位置
    for (let j = 0; j < len - 1 - i; j++) {
      if (arr[j] > arr[j + 1]) {
        const num = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = num;
      }
    }
    // 每次遍历结束，都能找到一个最大值，放在数组最后
  }
  return arr;
}
/**
 * split方法
 * @param url
 */
export function getParams(url: any) {
  const res: any = {};
  if (url.includes("?")) {
    const str = url.split("?")[1];
    const arr = str.split("&");
    arr.forEach((item: any) => {
      const key = item.split("=")[0];
      const val = item.split("=")[1];
      res[key] = decodeURIComponent(val); // 解码
    });
  }
  return res;
}

/**
 * @description [viewFile 查看文件]
 * @author  ZouMiao
 * @param {String} url [文件地址]
 * @returns {Null} [没有返回]
 */
export const viewFile = (url: any) => {
  const onlineViewType = ["doc", "docx", "xls", "xlsx", "xlsm", "ppt", "pptx"];
  const fileTypeName = url
    .substring(url.lastIndexOf(".") + 1, url.length)
    .split("?")[0];
  const isWord = onlineViewType.find((type) => type === fileTypeName);
  if (isWord) {
    url = "http://view.officeapps.live.com/op/view.aspx?src=" + url;
  }
  window.open(url, "_blank");
};
// 小写金额转大写金额
export function getAmountChinese(val: any) {
  const amount = +val;
  if (Number.isNaN(amount) || amount < 0) return "";
  const NUMBER = ["零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"];
  const N_UNIT1 = ["", "拾", "佰", "仟"];
  const N_UNIT2 = ["", "万", "亿"];
  const D_UNIT = ["角", "分", "厘", "毫"];
  const [integer, decimal] = amount.toString().split(".");
  if (integer && integer.length > 12) return "金额过大无法计算";
  let res = "";
  // 整数部分
  if (integer) {
    for (let i = 0, len = integer.length; i < len; i++) {
      const num = integer.charAt(i);
      const pos = len - i - 1; // 排除个位后 所处的索引位置
      if (num === "0") {
        // 当前位 等于 0 且下一位也等于 0 则可跳过计算
        if (i === len - 1) {
          if (integer.length === 1) res += "零"; // 0.35 这种情况不可跳过计算
          break;
        }
        if (integer.charAt(i + 1) === "0") continue;
      }
      res += NUMBER[parseInt(num)];
      if (parseInt(num)) res += N_UNIT1[pos % 4];
      if (pos % 4 === 0) res += N_UNIT2[Math.floor(pos / 4)];
    }
  }
  res += "圆";
  // 小数部分
  if (parseInt(decimal)) {
    for (let i = 0; i < 4; i++) {
      const num = decimal.charAt(i);
      if (parseInt(num)) res += NUMBER[parseInt(num)] + D_UNIT[i];
    }
  } else {
    res += "整";
  }
  return res;
}

export const changeNumMoneyToChinese = (money: any) => {
  const cnNums = ["零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"]; // 汉字的数字
  const cnIntRadice = ["", "拾", "佰", "仟"]; // 基本单位
  const cnIntUnits = ["", "万", "亿", "兆"]; // 对应整数部分扩展单位
  const cnDecUnits = ["角", "分", "毫", "厘"]; //  对应小数部分单位
  const cnInteger = "整"; // 整数金额时后面跟的字符
  const cnIntLast = "元"; // 整型完以后的单位
  const maxNum = 999999999999999.9999; // 最大处理的数字
  let IntegerNum; // 金额整数部分
  let DecimalNum; // 金额小数部分
  let ChineseStr = ""; // 输出的中文金额字符串
  let parts; // 分离金额后用的数组，预定义
  let Symbol = ""; // 正负值标记
  if (money === "") {
    return "";
  }

  money = parseFloat(money);
  if (money >= maxNum) {
    alert("超出最大处理数字");
    return "";
  }
  if (money === 0) {
    ChineseStr = cnNums[0] + cnIntLast + cnInteger;
    return ChineseStr;
  }
  if (money < 0) {
    money = -money;
    Symbol = "负";
  }
  money = money.toString(); // 转换为字符串
  if (money.indexOf(".") === -1) {
    IntegerNum = money;
    DecimalNum = "";
  } else {
    parts = money.split(".");
    IntegerNum = parts[0];
    DecimalNum = parts[1].substr(0, 4);
  }
  if (parseInt(IntegerNum, 10) > 0) {
    // 获取整型部分转换
    let zeroCount = 0;
    const IntLen = IntegerNum.length;
    for (let i = 0; i < IntLen; i++) {
      const n = IntegerNum.substr(i, 1);
      const p = IntLen - i - 1;
      const q = p / 4;
      const m = p % 4;
      if (n === "0") {
        zeroCount++;
      } else {
        if (zeroCount > 0) {
          ChineseStr += cnNums[0];
        }
        zeroCount = 0; // 归零
        ChineseStr += cnNums[parseInt(n, 0)] + cnIntRadice[m];
      }
      if (m === 0 && zeroCount < 4) {
        ChineseStr += cnIntUnits[q];
      }
    }
    ChineseStr += cnIntLast;
    // 整型部分处理完毕
  }
  if (DecimalNum !== "") {
    // 小数部分
    const decLen = DecimalNum.length;
    for (let i = 0; i < decLen; i++) {
      const n = DecimalNum.substr(i, 1);
      if (n !== "0") {
        ChineseStr += cnNums[Number(n)] + cnDecUnits[i];
      }
    }
  }
  if (ChineseStr === "") {
    ChineseStr += cnNums[0] + cnIntLast + cnInteger;
  } else if (DecimalNum === "") {
    ChineseStr += cnInteger;
  }
  ChineseStr = Symbol + ChineseStr;
  return ChineseStr;
};
